# Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
# reserved. Use of this source code is governed by a BSD-style license that
# can be found in the LICENSE file.

from date_util import *
from file_util import *
import os
import re
import shutil
import string
import sys
import textwrap
import time


def notify(msg):
    """ Display a message. """
    sys.stdout.write('  NOTE: '+msg+'\n')

def wrap_text(text, indent = '', maxchars = 80):
    """ Wrap the text to the specified number of characters. If
    necessary a line will be broken and wrapped after a word.
    """
    result = ''
    lines = textwrap.wrap(text, maxchars - len(indent))
    for line in lines:
        result += indent+line+'\n'
    return result

def wrap_code(code, indent = '    ', maxchars = 80, splitchars = '(=,'):
    """ Wrap the code lines to the specified number of characters. If
    necessary a line will be broken and wrapped after one of the split
    characters.
    """
    output = ''

    # normalize line endings
    code = code.replace("\r\n", "\n")

    # break the code chunk into lines
    lines = string.split(code, '\n')
    for line in lines:
        if len(line) <= maxchars:
            # line is short enough that it doesn't need to be wrapped
            output += line + '\n'
            continue

        # retrieve the whitespace at the beginning of the line for later use
        # as padding
        ws = ''
        for char in line:
            if char.isspace():
                ws += char
            else:
                break

        # iterate over all characters in the string keeping track of where the
        # last valid break character was found and wrapping the line
        # accordingly
        lastsplit = 0
        nextsplit = -1
        splitct = 0
        pos = 0
        for char in line:
            if splitchars.find(char) >= 0:
                # a new split position has been found
                nextsplit = pos
            size = pos - lastsplit + 1
            if splitct > 0:
                size += len(ws) + len(indent)
            if size >= maxchars:
                # the line is too long
                section = line[lastsplit:nextsplit+1]
                if len(section) > 0:
                    # output the line portion between the last split and the
                    # next split
                    if splitct > 0:
                        # start a new line and trim the line section
                        output += '\n'+ws+indent
                        section = string.strip(section)
                    output += section
                    lastsplit = nextsplit + 1
                    splitct += 1
            pos += 1
        if len(line) - lastsplit > 0:
            # output the remainder of the line
            section = line[lastsplit:]
            if splitct > 0:
                # start a new line and trim the line section
                output += '\n'+ws+indent
                section = string.strip(section)
            output += section
        output += '\n'

    return output

def is_base_class(clsname):
    """ Returns true if |clsname| is a known base (root) class in the object
        hierarchy.
    """
    return clsname == 'CefBaseRefCounted' or clsname == 'CefBaseScoped'

def get_capi_file_name(cppname):
    """ Convert a C++ header file name to a C API header file name. """
    return cppname[:-2]+'_capi.h'

def get_capi_name(cppname, isclassname, prefix = None):
    """ Convert a C++ CamelCaps name to a C API underscore name. """
    result = ''
    lastchr = ''
    for chr in cppname:
        # add an underscore if the current character is an upper case letter
        # and the last character was a lower case letter
        if len(result) > 0 and not chr.isdigit() \
            and string.upper(chr) == chr \
            and not string.upper(lastchr) == lastchr:
            result += '_'
        result += string.lower(chr)
        lastchr = chr

    if isclassname:
        result += '_t'

    if not prefix is None:
        if prefix[0:3] == 'cef':
            # if the prefix name is duplicated in the function name
            # remove that portion of the function name
            subprefix = prefix[3:]
            pos = result.find(subprefix)
            if pos >= 0:
                result = result[0:pos]+ result[pos+len(subprefix):]
        result = prefix+'_'+result

    return result

def get_wrapper_type_enum(cppname):
    """ Returns the wrapper type enumeration value for the specified C++ class
        name. """
    return 'WT_'+get_capi_name(cppname, False)[4:].upper()

def get_prev_line(body, pos):
    """ Retrieve the start and end positions and value for the line immediately
    before the line containing the specified position.
    """
    end = string.rfind(body, '\n', 0, pos)
    start = body.rfind('\n', 0, end)+1
    line = body[start:end]
    return { 'start' : start, 'end' : end, 'line' : line }

def get_comment(body, name):
    """ Retrieve the comment for a class or function. """
    result = []

    pos = body.find(name)
    while pos > 0:
        data = get_prev_line(body, pos)
        line = string.strip(data['line'])
        pos = data['start']
        if len(line) == 0:
            # check if the next previous line is a comment
            prevdata = get_prev_line(body, pos)
            if string.strip(prevdata['line'])[0:2] == '//':
                result.append(None)
            else:
                break
        elif line[0:2] == '/*' or line[-2:] == '*/':
            continue
        elif line[0:2] == '//':
            # keep the comment line including any leading spaces
            result.append(line[2:])
        else:
            break

    result.reverse()
    return result

def validate_comment(file, name, comment):
    """ Validate the comment array returned by get_comment(). """
    # Verify that the comment contains beginning and ending '///' as required by
    # CppDoc (the leading '//' from each line will already have been removed by
    # the get_comment() logic). There may be additional comments proceeding the
    # CppDoc block so we look at the quantity of lines equaling '/' and expect
    # the last line to be '/'.
    docct = 0
    for line in comment:
        if not line is None and len(line) > 0 and line == '/':
            docct = docct + 1
    if docct != 2 or len(comment) < 3 or comment[len(comment)-1] != '/':
        raise Exception('Missing or incorrect comment in %s for: %s' % \
            (file, name))

def format_comment(comment, indent, translate_map = None, maxchars = 80):
    """ Return the comments array as a formatted string. """
    result = ''
    wrapme = ''
    hasemptyline = False
    for line in comment:
        # if the line starts with a leading space, remove that space
        if not line is None and len(line) > 0 and line[0:1] == ' ':
            line = line[1:]
            didremovespace = True
        else:
            didremovespace = False

        if line is None or len(line) == 0 or line[0:1] == ' ' \
            or line[0:1] == '/':
            # the previous paragraph, if any, has ended
            if len(wrapme) > 0:
                if not translate_map is None:
                    # apply the translation
                    for key in translate_map.keys():
                        wrapme = wrapme.replace(key, translate_map[key])
                # output the previous paragraph
                result += wrap_text(wrapme, indent+'// ', maxchars)
                wrapme = ''

        if not line is None:
            if len(line) == 0 or line[0:1] == ' ' or line[0:1] == '/':
                # blank lines or anything that's further indented should be
                # output as-is
                result += indent+'//'
                if len(line) > 0:
                    if didremovespace:
                        result += ' '+line
                    else:
                        result += line
                result += '\n'
            else:
                # add to the current paragraph
                wrapme += line+' '
        else:
            # output an empty line
            hasemptyline = True
            result += '\n'

    if len(wrapme) > 0:
        if not translate_map is None:
            # apply the translation
            for key in translate_map.keys():
                wrapme = wrapme.replace(key, translate_map[key])
        # output the previous paragraph
        result += wrap_text(wrapme, indent+'// ', maxchars)

    if hasemptyline:
        # an empty line means a break between comments, so the comment is
        # probably a section heading and should have an extra line before it
        result = '\n' + result
    return result

def format_translation_changes(old, new):
    """ Return a comment stating what is different between the old and new
    function prototype parts.
    """
    changed = False
    result = ''

    # normalize C API attributes
    oldargs = [x.replace('struct _', '') for x in old['args']]
    oldretval = old['retval'].replace('struct _', '')
    newargs = [x.replace('struct _', '') for x in new['args']]
    newretval = new['retval'].replace('struct _', '')

    # check if the prototype has changed
    oldset = set(oldargs)
    newset = set(newargs)
    if len(oldset.symmetric_difference(newset)) > 0:
        changed = True
        result += '\n  // WARNING - CHANGED ATTRIBUTES'

        # in the implementation set only
        oldonly = oldset.difference(newset)
        for arg in oldonly:
            result += '\n  //   REMOVED: '+arg

        # in the current set only
        newonly = newset.difference(oldset)
        for arg in newonly:
            result += '\n  //   ADDED:   '+arg

    # check if the return value has changed
    if oldretval != newretval:
        changed = True
        result += '\n  // WARNING - CHANGED RETURN VALUE'+ \
                  '\n  //   WAS: '+old['retval']+ \
                  '\n  //   NOW: '+new['retval']

    if changed:
        result += '\n  #pragma message("Warning: "__FILE__": '+new['name']+ \
                  ' prototype has changed")\n'

    return result

def format_translation_includes(header, body):
    """ Return the necessary list of includes based on the contents of the
    body.
    """
    result = ''

    # <algorithm> required for VS2013.
    if body.find('std::min') > 0 or body.find('std::max') > 0:
        result += '#include <algorithm>\n'

    if body.find('cef_api_hash(') > 0:
        result += '#include "include/cef_version.h"\n'

    # identify what CppToC classes are being used
    p = re.compile('([A-Za-z0-9_]{1,})CppToC')
    list = sorted(set(p.findall(body)))
    for item in list:
        directory = ''
        if not is_base_class(item):
            cls = header.get_class(item)
            dir = cls.get_file_directory()
            if not dir is None:
                directory = dir+'/'
        result += '#include "libcef_dll/cpptoc/'+directory+ \
                  get_capi_name(item[3:], False)+'_cpptoc.h"\n'

    # identify what CToCpp classes are being used
    p = re.compile('([A-Za-z0-9_]{1,})CToCpp')
    list = sorted(set(p.findall(body)))
    for item in list:
        directory = ''
        if not is_base_class(item):
            cls = header.get_class(item)
            dir = cls.get_file_directory()
            if not dir is None:
                directory = dir+'/'
        result += '#include "libcef_dll/ctocpp/'+directory+ \
                  get_capi_name(item[3:], False)+'_ctocpp.h"\n'

    if body.find('transfer_') > 0:
        result += '#include "libcef_dll/transfer_util.h"\n'

    return result

def str_to_dict(str):
    """ Convert a string to a dictionary. If the same key has multiple values
        the values will be stored in a list. """
    dict = {}
    parts = string.split(str, ',')
    for part in parts:
        part = string.strip(part)
        if len(part) == 0:
            continue
        sparts = string.split(part, '=')
        if len(sparts) > 2:
            raise Exception('Invalid dictionary pair format: '+part)
        name = string.strip(sparts[0])
        if len(sparts) == 2:
            val = string.strip(sparts[1])
        else:
            val = True
        if name in dict:
            # a value with this name already exists
            curval = dict[name]
            if not isinstance(curval, list):
                # convert the string value to a list
                dict[name] = [curval]
            dict[name].append(val)
        else:
            dict[name] = val
    return dict

def dict_to_str(dict):
    """ Convert a dictionary to a string. """
    str = []
    for name in dict.keys():
        if not isinstance(dict[name], list):
            if dict[name] is True:
                # currently a bool value
                str.append(name)
            else:
                # currently a string value
                str.append(name+'='+dict[name])
        else:
            # currently a list value
            for val in dict[name]:
                str.append(name+'='+val)
    return string.join(str, ',')


# regex for matching comment-formatted attributes
_cre_attrib = '/\*--cef\(([A-Za-z0-9_ ,=:\n]{0,})\)--\*/'
# regex for matching class and function names
_cre_cfname = '([A-Za-z0-9_]{1,})'
# regex for matching class and function names including path separators
_cre_cfnameorpath = '([A-Za-z0-9_\/]{1,})'
# regex for matching function return values
_cre_retval = '([A-Za-z0-9_<>:,\*\&]{1,})'
# regex for matching typedef value and name combination
_cre_typedef = '([A-Za-z0-9_<>:,\*\&\s]{1,})'
# regex for matching function return value and name combination
_cre_func   = '([A-Za-z][A-Za-z0-9_<>:,\*\&\s]{1,})'
# regex for matching virtual function modifiers
_cre_vfmod  = '([A-Za-z0-9_]{0,})'
# regex for matching arbitrary whitespace
_cre_space  = '[\s]{1,}'
# regex for matching optional virtual keyword
_cre_virtual = '(?:[\s]{1,}virtual){0,1}'

# Simple translation types. Format is:
#   'cpp_type' : ['capi_type', 'capi_default_value']
_simpletypes = {
    'void' : ['void', ''],
    'void*' : ['void*', 'NULL'],
    'int' : ['int', '0'],
    'int32' : ['int32', '0'],
    'uint32' : ['uint32', '0'],
    'int64' : ['int64', '0'],
    'uint64' : ['uint64', '0'],
    'double' : ['double', '0'],
    'float' : ['float', '0'],
    'long' : ['long', '0'],
    'unsigned long' : ['unsigned long', '0'],
    'long long' : ['long long', '0'],
    'size_t' : ['size_t', '0'],
    'bool' : ['int', '0'],
    'char': ['char', '0'],
    'char* const': ['char* const', 'NULL'],
    'cef_color_t': ['cef_color_t', '0'],
    'cef_json_parser_error_t': ['cef_json_parser_error_t', 'JSON_NO_ERROR'],
    'cef_plugin_policy_t': ['cef_plugin_policy_t', 'PLUGIN_POLICY_ALLOW'],
    'CefCursorHandle' : ['cef_cursor_handle_t', 'kNullCursorHandle'],
    'CefCompositionUnderline' : ['cef_composition_underline_t',
                                 'CefCompositionUnderline()'],
    'CefEventHandle' : ['cef_event_handle_t', 'kNullEventHandle'],
    'CefWindowHandle' : ['cef_window_handle_t', 'kNullWindowHandle'],
    'CefPoint' : ['cef_point_t', 'CefPoint()'],
    'CefRect' : ['cef_rect_t', 'CefRect()'],
    'CefSize' : ['cef_size_t', 'CefSize()'],
    'CefRange' : ['cef_range_t', 'CefRange()'],
    'CefDraggableRegion' : ['cef_draggable_region_t', 'CefDraggableRegion()'],
    'CefThreadId' : ['cef_thread_id_t', 'TID_UI'],
    'CefTime' : ['cef_time_t', 'CefTime()'],
}

def get_function_impls(content, ident):
    """ Retrieve the function parts from the specified contents as a set of
    return value, name, arguments and body. Ident must occur somewhere in
    the value.
    """
    # extract the functions
    p = re.compile('\n'+_cre_func+'\((.*?)\)([A-Za-z0-9_\s]{0,})'+
                   '\{(.*?)\n\}',
                   re.MULTILINE | re.DOTALL)
    list = p.findall(content)

    # build the function map with the function name as the key
    result = []
    for retval, argval, vfmod, body in list:
        if retval.find(ident) < 0:
            # the identifier was not found
            continue

        # remove the identifier
        retval = string.replace(retval, ident, '')
        retval = string.strip(retval)

        # retrieve the function name
        parts = string.split(retval, ' ')
        name = parts[-1]
        del parts[-1]
        retval = string.join(parts, ' ')

        # parse the arguments
        args = []
        for v in string.split(argval, ','):
            v = string.strip(v)
            if len(v) > 0:
                args.append(v)

        result.append({
            'retval' : string.strip(retval),
            'name' : name,
            'args' : args,
            'vfmod' : string.strip(vfmod),
            'body' : body
        })

    return result

def get_next_function_impl(existing, name):
    result = None
    for item in existing:
        if item['name'] == name:
            result = item
            existing.remove(item)
            break
    return result

def get_copyright():
    result = \
"""// Copyright (c) $YEAR$ The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool. If making changes by
// hand only do so within the body of existing method and function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//

"""
    # add the copyright year
    return result.replace('$YEAR$', get_year())


class obj_header:
    """ Class representing a C++ header file. """

    def __init__(self):
        self.filenames = []
        self.typedefs = []
        self.funcs = []
        self.classes = []
        self.root_directory = None

    def set_root_directory(self, root_directory):
        """ Set the root directory. """
        self.root_directory = root_directory

    def add_directory(self, directory, excluded_files = []):
        """ Add all header files from the specified directory. """
        files = get_files(os.path.join(directory, '*.h'))
        for file in files:
            if len(excluded_files) == 0 or \
                not os.path.split(file)[1] in excluded_files:
                self.add_file(file)

    def add_file(self, filepath):
        """ Add a header file. """

        if self.root_directory is None:
            filename = os.path.split(filepath)[1]
        else:
            filename = os.path.relpath(filepath, self.root_directory)
            filename = filename.replace('\\', '/')

        # read the input file into memory
        self.add_data(filename, read_file(filepath))

    def add_data(self, filename, data):
        """ Add header file contents. """

        added = False

        # remove space from between template definition end brackets
        data = data.replace("> >", ">>")

        # extract global typedefs
        p = re.compile('\ntypedef'+_cre_space+_cre_typedef+';',
                       re.MULTILINE | re.DOTALL)
        list = p.findall(data)
        if len(list) > 0:
            # build the global typedef objects
            for value in list:
                pos = value.rfind(' ')
                if pos < 0:
                  raise Exception('Invalid typedef: '+value)
                alias = value[pos+1:].strip()
                value = value[:pos].strip()
                self.typedefs.append(obj_typedef(self, filename, value, alias))

        # extract global functions
        p = re.compile('\n'+_cre_attrib+'\n'+_cre_func+'\((.*?)\)',
                       re.MULTILINE | re.DOTALL)
        list = p.findall(data)
        if len(list) > 0:
            added = True

            # build the global function objects
            for attrib, retval, argval in list:
                comment = get_comment(data, retval+'('+argval+');')
                validate_comment(filename, retval, comment)
                self.funcs.append(obj_function(self, filename, attrib, retval,
                                               argval, comment))

        # extract includes
        p = re.compile('\n#include \"include/'+_cre_cfnameorpath+'.h')
        includes = p.findall(data)

        # extract forward declarations
        p = re.compile('\nclass'+_cre_space+_cre_cfname+';')
        forward_declares = p.findall(data)

        # extract classes
        p = re.compile('\n'+_cre_attrib+
                       '\nclass'+_cre_space+_cre_cfname+_cre_space+
                       ':'+_cre_space+'public'+_cre_virtual+
                       _cre_space+_cre_cfname+_cre_space+
                       '{(.*?)\n};', re.MULTILINE | re.DOTALL)
        list = p.findall(data)
        if len(list) > 0:
            added = True

            # build the class objects
            for attrib, name, parent_name, body in list:
                comment = get_comment(data, name+' :')
                validate_comment(filename, name, comment)
                self.classes.append(
                    obj_class(self, filename, attrib, name, parent_name, body,
                              comment, includes, forward_declares))

        if added:
            # a global function or class was read from the header file
            self.filenames.append(filename)

    def __repr__(self):
        result = ''

        if len(self.typedefs) > 0:
            strlist = []
            for cls in self.typedefs:
                strlist.append(str(cls))
            result += string.join(strlist, "\n") + "\n\n"

        if len(self.funcs) > 0:
            strlist = []
            for cls in self.funcs:
                strlist.append(str(cls))
            result += string.join(strlist, "\n") + "\n\n"

        if len(self.classes) > 0:
            strlist = []
            for cls in self.classes:
                strlist.append(str(cls))
            result += string.join(strlist, "\n")

        return result

    def get_file_names(self):
        """ Return the array of header file names. """
        return self.filenames

    def get_typedefs(self):
        """ Return the array of typedef objects. """
        return self.typedefs

    def get_funcs(self, filename = None):
        """ Return the array of function objects. """
        if filename is None:
            return self.funcs
        else:
            # only return the functions in the specified file
            res = []
            for func in self.funcs:
                if func.get_file_name() == filename:
                    res.append(func)
            return res

    def get_classes(self, filename = None):
        """ Return the array of class objects. """
        if filename is None:
            return self.classes
        else:
            # only return the classes in the specified file
            res = []
            for cls in self.classes:
                if cls.get_file_name() == filename:
                    res.append(cls)
            return res

    def get_class(self, classname, defined_structs = None):
        """ Return the specified class or None if not found. """
        for cls in self.classes:
            if cls.get_name() == classname:
                return cls
            elif not defined_structs is None:
                defined_structs.append(cls.get_capi_name())
        return None

    def get_class_names(self):
        """ Returns the names of all classes in this object. """
        result = []
        for cls in self.classes:
            result.append(cls.get_name())
        return result

    def get_base_class_name(self, classname):
        """ Returns the base (root) class name for |classname|. """
        cur_cls = self.get_class(classname)
        while True:
            parent_name = cur_cls.get_parent_name()
            if is_base_class(parent_name):
                return parent_name
            else:
                parent_cls = self.get_class(parent_name)
                if parent_cls is None:
                    break
            cur_cls = self.get_class(parent_name)
        return None

    def get_types(self, list):
        """ Return a dictionary mapping data types to analyzed values. """
        for cls in self.typedefs:
            cls.get_types(list)

        for cls in self.classes:
            cls.get_types(list)

    def get_alias_translation(self, alias):
        """ Return a translation of alias to value based on typedef
            statements. """
        for cls in self.typedefs:
            if cls.alias == alias:
                return cls.value
        return None

    def get_analysis(self, value, named = True):
        """ Return an analysis of the value based the header file context. """
        return obj_analysis([self], value, named)

    def get_defined_structs(self):
        """ Return a list of already defined structure names. """
        return ['cef_print_info_t', 'cef_window_info_t', 'cef_base_ref_counted_t', 'cef_base_scoped_t']

    def get_capi_translations(self):
        """ Return a dictionary that maps C++ terminology to C API terminology.
        """
        # strings that will be changed in C++ comments
        map = {
            'class' : 'structure',
            'Class' : 'Structure',
            'interface' : 'structure',
            'Interface' : 'Structure',
            'true' : 'true (1)',
            'false' : 'false (0)',
            'empty' : 'NULL',
            'method' : 'function'
        }

        # add mappings for all classes and functions
        funcs = self.get_funcs()
        for func in funcs:
            map[func.get_name()+'()'] = func.get_capi_name()+'()'

        classes = self.get_classes()
        for cls in classes:
            map[cls.get_name()] = cls.get_capi_name()

            funcs = cls.get_virtual_funcs()
            for func in funcs:
                map[func.get_name()+'()'] = func.get_capi_name()+'()'

            funcs = cls.get_static_funcs()
            for func in funcs:
                map[func.get_name()+'()'] = func.get_capi_name()+'()'

        return map


class obj_class:
    """ Class representing a C++ class. """

    def __init__(self, parent, filename, attrib, name, parent_name, body,
                 comment, includes, forward_declares):
        if not isinstance(parent, obj_header):
            raise Exception('Invalid parent object type')

        self.parent = parent
        self.filename = filename
        self.attribs = str_to_dict(attrib)
        self.name = name
        self.parent_name = parent_name
        self.comment = comment
        self.includes = includes
        self.forward_declares = forward_declares

        # extract typedefs
        p = re.compile('\n'+_cre_space+'typedef'+_cre_space+_cre_typedef+';',
                       re.MULTILINE | re.DOTALL)
        list = p.findall(body)

        # build the typedef objects
        self.typedefs = []
        for value in list:
            pos = value.rfind(' ')
            if pos < 0:
              raise Exception('Invalid typedef: '+value)
            alias = value[pos+1:].strip()
            value = value[:pos].strip()
            self.typedefs.append(obj_typedef(self, filename, value, alias))

        # extract static functions
        p = re.compile('\n'+_cre_space+_cre_attrib+'\n'+_cre_space+'static'+
                       _cre_space+_cre_func+'\((.*?)\)',
                       re.MULTILINE | re.DOTALL)
        list = p.findall(body)

        # build the static function objects
        self.staticfuncs = []
        for attrib, retval, argval in list:
            comment = get_comment(body, retval+'('+argval+')')
            validate_comment(filename, retval, comment)
            self.staticfuncs.append(
                obj_function_static(self, attrib, retval, argval, comment))

        # extract virtual functions
        p = re.compile('\n'+_cre_space+_cre_attrib+'\n'+_cre_space+'virtual'+
                       _cre_space+_cre_func+'\((.*?)\)'+_cre_space+_cre_vfmod,
                       re.MULTILINE | re.DOTALL)
        list = p.findall(body)

        # build the virtual function objects
        self.virtualfuncs = []
        for attrib, retval, argval, vfmod in list:
            comment = get_comment(body, retval+'('+argval+')')
            validate_comment(filename, retval, comment)
            self.virtualfuncs.append(
                obj_function_virtual(self, attrib, retval, argval, comment,
                                     vfmod))

    def __repr__(self):
        result = '/* '+dict_to_str(self.attribs)+' */ class '+self.name+"\n{"

        if len(self.typedefs) > 0:
            result += "\n\t"
            strlist = []
            for cls in self.typedefs:
                strlist.append(str(cls))
            result += string.join(strlist, "\n\t")

        if len(self.staticfuncs) > 0:
            result += "\n\t"
            strlist = []
            for cls in self.staticfuncs:
                strlist.append(str(cls))
            result += string.join(strlist, "\n\t")

        if len(self.virtualfuncs) > 0:
            result += "\n\t"
            strlist = []
            for cls in self.virtualfuncs:
                strlist.append(str(cls))
            result += string.join(strlist, "\n\t")

        result += "\n};\n"
        return result

    def get_file_name(self):
        """ Return the C++ header file name. Includes the directory component,
            if any. """
        return self.filename

    def get_capi_file_name(self):
        """ Return the CAPI header file name. Includes the directory component,
            if any. """
        return get_capi_file_name(self.filename)

    def get_file_directory(self):
        """ Return the file directory component, if any. """
        pos = self.filename.rfind('/')
        if pos >= 0:
            return self.filename[:pos]
        return None

    def get_name(self):
        """ Return the class name. """
        return self.name

    def get_capi_name(self):
        """ Return the CAPI structure name for this class. """
        return get_capi_name(self.name, True)

    def get_parent_name(self):
        """ Return the parent class name. """
        return self.parent_name

    def get_parent_capi_name(self):
        """ Return the CAPI structure name for the parent class. """
        return get_capi_name(self.parent_name, True)

    def has_parent(self, parent_name):
        """ Returns true if this class has the specified class anywhere in its
            inheritance hierarchy. """
        # Every class has a known base class as the top-most parent.
        if is_base_class(parent_name) or parent_name == self.parent_name:
            return True
        if is_base_class(self.parent_name):
            return False

        cur_cls = self.parent.get_class(self.parent_name)
        while True:
            cur_parent_name = cur_cls.get_parent_name()
            if is_base_class(cur_parent_name):
                break
            elif cur_parent_name == parent_name:
                return True
            cur_cls = self.parent.get_class(cur_parent_name)

        return False

    def get_comment(self):
        """ Return the class comment as an array of lines. """
        return self.comment

    def get_includes(self):
        """ Return the list of classes that are included from this class'
            header file. """
        return self.includes

    def get_forward_declares(self):
        """ Return the list of classes that are forward declared for this
            class. """
        return self.forward_declares

    def get_attribs(self):
        """ Return all attributes as a dictionary. """
        return self.attribs

    def has_attrib(self, name):
        """ Return true if the specified attribute exists. """
        return name in self.attribs

    def get_attrib(self, name):
        """ Return the first or only value for specified attribute. """
        if name in self.attribs:
            if isinstance(self.attribs[name], list):
                # the value is a list
                return self.attribs[name][0]
            else:
                # the value is a string
                return self.attribs[name]
        return None

    def get_attrib_list(self, name):
        """ Return all values for specified attribute as a list. """
        if name in self.attribs:
            if isinstance(self.attribs[name], list):
                # the value is already a list
                return self.attribs[name]
            else:
                # convert the value to a list
                return [self.attribs[name]]
        return None

    def get_typedefs(self):
        """ Return the array of typedef objects. """
        return self.typedefs

    def has_typedef_alias(self, alias):
        """ Returns true if the specified typedef alias is defined in the scope
            of this class declaration. """
        for typedef in self.typedefs:
          if typedef.get_alias() == alias:
            return True
        return False

    def get_static_funcs(self):
        """ Return the array of static function objects. """
        return self.staticfuncs

    def get_virtual_funcs(self):
        """ Return the array of virtual function objects. """
        return self.virtualfuncs

    def get_types(self, list):
        """ Return a dictionary mapping data types to analyzed values. """
        for cls in self.typedefs:
            cls.get_types(list)

        for cls in self.staticfuncs:
            cls.get_types(list)

        for cls in self.virtualfuncs:
            cls.get_types(list)

    def get_alias_translation(self, alias):
        for cls in self.typedefs:
            if cls.alias == alias:
                return cls.value
        return None

    def get_analysis(self, value, named = True):
        """ Return an analysis of the value based on the class definition
        context.
        """
        return obj_analysis([self, self.parent], value, named)

    def is_library_side(self):
        """ Returns true if the class is implemented by the library. """
        return self.attribs['source'] == 'library'

    def is_client_side(self):
        """ Returns true if the class is implemented by the client. """
        return self.attribs['source'] == 'client'


class obj_typedef:
    """ Class representing a typedef statement. """

    def __init__(self, parent, filename, value, alias):
        if not isinstance(parent, obj_header) \
            and not isinstance(parent, obj_class):
            raise Exception('Invalid parent object type')

        self.parent = parent
        self.filename = filename
        self.alias = alias
        self.value = self.parent.get_analysis(value, False)

    def __repr__(self):
        return 'typedef '+self.value.get_type()+' '+self.alias+';'

    def get_file_name(self):
        """ Return the C++ header file name. """
        return self.filename

    def get_capi_file_name(self):
        """ Return the CAPI header file name. """
        return get_capi_file_name(self.filename)

    def get_alias(self):
        """ Return the alias. """
        return self.alias

    def get_value(self):
        """ Return an analysis of the value based on the class or header file
        definition context.
        """
        return self.value

    def get_types(self, list):
        """ Return a dictionary mapping data types to analyzed values. """
        name = self.value.get_type()
        if not name in list:
            list[name] = self.value


class obj_function:
    """ Class representing a function. """

    def __init__(self, parent, filename, attrib, retval, argval, comment):
        self.parent = parent
        self.filename = filename
        self.attribs = str_to_dict(attrib)
        self.retval = obj_argument(self, retval)
        self.name = self.retval.remove_name()
        self.comment = comment

        # build the argument objects
        self.arguments = []
        arglist = string.split(argval, ',')
        argindex = 0
        while argindex < len(arglist):
            arg = arglist[argindex]
            if arg.find('<') >= 0 and arg.find('>') == -1:
                # We've split inside of a template type declaration. Join the
                # next argument with this argument.
                argindex += 1
                arg += ',' + arglist[argindex]

            arg = string.strip(arg)
            if len(arg) > 0:
                argument = obj_argument(self, arg)
                if argument.needs_attrib_count_func() and \
                    argument.get_attrib_count_func() is None:
                    raise Exception("A 'count_func' attribute is required "+ \
                                    "for the '"+argument.get_name()+ \
                                    "' parameter to "+self.get_qualified_name())
                self.arguments.append(argument)

            argindex += 1

        if self.retval.needs_attrib_default_retval() and \
            self.retval.get_attrib_default_retval() is None:
            raise Exception("A 'default_retval' attribute is required for "+ \
                            self.get_qualified_name())

    def __repr__(self):
        return '/* '+dict_to_str(self.attribs)+' */ '+self.get_cpp_proto()

    def get_file_name(self):
        """ Return the C++ header file name. """
        return self.filename

    def get_capi_file_name(self):
        """ Return the CAPI header file name. """
        return get_capi_file_name(self.filename)

    def get_name(self):
        """ Return the function name. """
        return self.name

    def get_qualified_name(self):
        """ Return the fully qualified function name. """
        if isinstance(self.parent, obj_header):
            # global function
            return self.name
        else:
            # member function
            return self.parent.get_name()+'::'+self.name

    def get_capi_name(self, prefix = None):
        """ Return the CAPI function name. """
        if 'capi_name' in self.attribs:
            return self.attribs['capi_name']
        return get_capi_name(self.name, False, prefix)

    def get_comment(self):
        """ Return the function comment as an array of lines. """
        return self.comment

    def get_attribs(self):
        """ Return all attributes as a dictionary. """
        return self.attribs

    def has_attrib(self, name):
        """ Return true if the specified attribute exists. """
        return name in self.attribs

    def get_attrib(self, name):
        """ Return the first or only value for specified attribute. """
        if name in self.attribs:
            if isinstance(self.attribs[name], list):
                # the value is a list
                return self.attribs[name][0]
            else:
                # the value is a string
                return self.attribs[name]
        return None

    def get_attrib_list(self, name):
        """ Return all values for specified attribute as a list. """
        if name in self.attribs:
            if isinstance(self.attribs[name], list):
                # the value is already a list
                return self.attribs[name]
            else:
                # convert the value to a list
                return [self.attribs[name]]
        return None

    def get_retval(self):
        """ Return the return value object. """
        return self.retval

    def get_arguments(self):
        """ Return the argument array. """
        return self.arguments

    def get_types(self, list):
        """ Return a dictionary mapping data types to analyzed values. """
        for cls in self.arguments:
            cls.get_types(list)

    def get_capi_parts(self, defined_structs = [], prefix = None):
        """ Return the parts of the C API function definition. """
        retval = ''
        dict = self.retval.get_type().get_capi(defined_structs)
        if dict['format'] == 'single':
            retval = dict['value']

        name = self.get_capi_name(prefix)
        args = []

        if isinstance(self, obj_function_virtual):
            # virtual functions get themselves as the first argument
            str = 'struct _'+self.parent.get_capi_name()+'* self'
            if isinstance(self, obj_function_virtual) and self.is_const():
                # const virtual functions get const self pointers
                str = 'const '+str
            args.append(str)

        if len(self.arguments) > 0:
            for cls in self.arguments:
                type = cls.get_type()
                dict = type.get_capi(defined_structs)
                if dict['format'] == 'single':
                    args.append(dict['value'])
                elif dict['format'] == 'multi-arg':
                    # add an additional argument for the size of the array
                    type_name = type.get_name()
                    if type.is_const():
                        # for const arrays pass the size argument by value
                        args.append('size_t '+type_name+'Count')
                    else:
                        # for non-const arrays pass the size argument by address
                        args.append('size_t* '+type_name+'Count')
                    args.append(dict['value'])

        return { 'retval' : retval, 'name' : name, 'args' : args }

    def get_capi_proto(self, defined_structs = [], prefix = None):
        """ Return the prototype of the C API function. """
        parts = self.get_capi_parts(defined_structs, prefix)
        result = parts['retval']+' '+parts['name']+ \
                 '('+string.join(parts['args'], ', ')+')'
        return result

    def get_cpp_parts(self, isimpl = False):
        """ Return the parts of the C++ function definition. """
        retval = str(self.retval)
        name = self.name

        args = []
        if len(self.arguments) > 0:
            for cls in self.arguments:
                args.append(str(cls))

        if isimpl and isinstance(self, obj_function_virtual):
            # enumeration return values must be qualified with the class name
            # if the type is defined in the class declaration scope.
            type = self.get_retval().get_type()
            if type.is_result_struct() and type.is_result_struct_enum() and \
                self.parent.has_typedef_alias(retval):
                retval = self.parent.get_name()+'::'+retval

        return { 'retval' : retval, 'name' : name, 'args' : args }

    def get_cpp_proto(self, classname = None):
        """ Return the prototype of the C++ function. """
        parts = self.get_cpp_parts()
        result = parts['retval']+' '
        if not classname is None:
            result += classname+'::'
        result += parts['name']+'('+string.join(parts['args'], ', ')+')'
        if isinstance(self, obj_function_virtual) and self.is_const():
            result += ' const'
        return result

    def is_same_side(self, other_class_name):
        """ Returns true if this function is on the same side (library or
            client) and the specified class. """
        if isinstance(self.parent, obj_class):
            # this function is part of a class
            this_is_library_side = self.parent.is_library_side()
            header = self.parent.parent
        else:
            # this function is global
            this_is_library_side = True
            header = self.parent

        if is_base_class(other_class_name):
            other_is_library_side = False
        else:
            other_class = header.get_class(other_class_name)
            if other_class is None:
                raise Exception('Unknown class: '+other_class_name)
            other_is_library_side = other_class.is_library_side()

        return other_is_library_side == this_is_library_side


class obj_function_static(obj_function):
    """ Class representing a static function. """

    def __init__(self, parent, attrib, retval, argval, comment):
        if not isinstance(parent, obj_class):
            raise Exception('Invalid parent object type')
        obj_function.__init__(self, parent, parent.filename, attrib, retval,
                              argval, comment)

    def __repr__(self):
        return 'static '+obj_function.__repr__(self)+';'

    def get_capi_name(self, prefix = None):
        """ Return the CAPI function name. """
        if prefix is None:
            # by default static functions are prefixed with the class name
            prefix = get_capi_name(self.parent.get_name(), False)
        return obj_function.get_capi_name(self, prefix)

class obj_function_virtual(obj_function):
    """ Class representing a virtual function. """

    def __init__(self, parent, attrib, retval, argval, comment, vfmod):
        if not isinstance(parent, obj_class):
            raise Exception('Invalid parent object type')
        obj_function.__init__(self, parent, parent.filename, attrib, retval,
                              argval, comment)
        if vfmod == 'const':
            self.isconst = True
        else:
            self.isconst = False

    def __repr__(self):
        return 'virtual '+obj_function.__repr__(self)+';'

    def is_const(self):
        """ Returns true if the method declaration is const. """
        return self.isconst


class obj_argument:
    """ Class representing a function argument. """

    def __init__(self, parent, argval):
        if not isinstance(parent, obj_function):
            raise Exception('Invalid parent object type')

        self.parent = parent
        self.type = self.parent.parent.get_analysis(argval)

    def __repr__(self):
        result = ''
        if self.type.is_const():
            result += 'const '
        result += self.type.get_type()
        if self.type.is_byref():
            result += '&'
        elif self.type.is_byaddr():
            result += '*'
        if self.type.has_name():
            result += ' '+self.type.get_name()
        return result

    def get_name(self):
        """ Return the name for this argument. """
        return self.type.get_name()

    def remove_name(self):
        """ Remove and return the name value. """
        name = self.type.get_name()
        self.type.name = None
        return name

    def get_type(self):
        """ Return an analysis of the argument type based on the class
        definition context.
        """
        return self.type

    def get_types(self, list):
        """ Return a dictionary mapping data types to analyzed values. """
        name = self.type.get_type()
        if not name in list:
            list[name] = self.type

    def needs_attrib_count_func(self):
        """ Returns true if this argument requires a 'count_func' attribute. """
        # A 'count_func' attribute is required for non-const non-string vector
        # attribute types
        return self.type.has_name() and \
            self.type.is_result_vector() and \
            not self.type.is_result_vector_string() and \
            not self.type.is_const()

    def get_attrib_count_func(self):
        """ Returns the count function for this argument. """
        # The 'count_func' attribute value format is name:function
        if not self.parent.has_attrib('count_func'):
            return None
        name = self.type.get_name()
        vals = self.parent.get_attrib_list('count_func')
        for val in vals:
            parts = string.split(val, ':')
            if len(parts) != 2:
                raise Exception("Invalid 'count_func' attribute value for "+ \
                                self.parent.get_qualified_name()+': '+val)
            if string.strip(parts[0]) == name:
                return string.strip(parts[1])
        return None

    def needs_attrib_default_retval(self):
        """ Returns true if this argument requires a 'default_retval' attribute.
        """
        # A 'default_retval' attribute is required for enumeration return value
        # types.
        return not self.type.has_name() and \
            self.type.is_result_struct() and \
            self.type.is_result_struct_enum()

    def get_attrib_default_retval(self):
        """ Returns the defualt return value for this argument. """
        return self.parent.get_attrib('default_retval')

    def get_arg_type(self):
        """ Returns the argument type as defined in translator.README.txt. """
        if not self.type.has_name():
            raise Exception('Cannot be called for retval types')

        # simple or enumeration type
        if (self.type.is_result_simple() and \
                self.type.get_type() != 'bool') or \
           (self.type.is_result_struct() and \
                self.type.is_result_struct_enum()):
            if self.type.is_byref():
                if self.type.is_const():
                    return 'simple_byref_const'
                return 'simple_byref'
            elif self.type.is_byaddr():
                return 'simple_byaddr'
            return 'simple_byval'

        # boolean type
        if self.type.get_type() == 'bool':
            if self.type.is_byref():
                return 'bool_byref'
            elif self.type.is_byaddr():
                return 'bool_byaddr'
            return 'bool_byval'

        # structure type
        if self.type.is_result_struct() and self.type.is_byref():
            if self.type.is_const():
                return 'struct_byref_const'
            return 'struct_byref'

        # string type
        if self.type.is_result_string() and self.type.is_byref():
            if self.type.is_const():
                return 'string_byref_const'
            return 'string_byref'

        # *ptr type
        if self.type.is_result_ptr():
            prefix = self.type.get_result_ptr_type_prefix()
            same_side = self.parent.is_same_side(self.type.get_ptr_type())
            if self.type.is_byref():
                if same_side:
                    return prefix + 'ptr_same_byref'
                return prefix + 'ptr_diff_byref'
            if same_side:
                return prefix + 'ptr_same'
            return prefix + 'ptr_diff'

        if self.type.is_result_vector():
            # all vector types must be passed by reference
            if not self.type.is_byref():
                return 'invalid'

            if self.type.is_result_vector_string():
                # string vector type
                if self.type.is_const():
                    return 'string_vec_byref_const'
                return 'string_vec_byref'

            if self.type.is_result_vector_simple():
                if self.type.get_vector_type() != 'bool':
                    # simple/enumeration vector types
                    if self.type.is_const():
                        return 'simple_vec_byref_const'
                    return 'simple_vec_byref'

                # boolean vector types
                if self.type.is_const():
                    return 'bool_vec_byref_const'
                return 'bool_vec_byref'

            if self.type.is_result_vector_ptr():
                # *ptr vector types
                prefix = self.type.get_result_vector_ptr_type_prefix()
                same_side = self.parent.is_same_side(self.type.get_ptr_type())
                if self.type.is_const():
                    if same_side:
                        return prefix + 'ptr_vec_same_byref_const'
                    return prefix + 'ptr_vec_diff_byref_const'
                if same_side:
                    return prefix + 'ptr_vec_same_byref'
                return prefix + 'ptr_vec_diff_byref'

        # string single map type
        if self.type.is_result_map_single():
            if not self.type.is_byref():
                return 'invalid'
            if self.type.is_const():
                return 'string_map_single_byref_const'
            return 'string_map_single_byref'

        # string multi map type
        if self.type.is_result_map_multi():
            if not self.type.is_byref():
                return 'invalid'
            if self.type.is_const():
                return 'string_map_multi_byref_const'
            return 'string_map_multi_byref'

        return 'invalid'

    def get_retval_type(self):
        """ Returns the retval type as defined in translator.README.txt. """
        if self.type.has_name():
            raise Exception('Cannot be called for argument types')

        # unsupported modifiers
        if self.type.is_const() or self.type.is_byref() or \
            self.type.is_byaddr():
            return 'invalid'

        # void types don't have a return value
        if self.type.get_type() == 'void':
            return 'none'

        if (self.type.is_result_simple() and \
                self.type.get_type() != 'bool') or \
           (self.type.is_result_struct() and self.type.is_result_struct_enum()):
            return 'simple'

        if self.type.get_type() == 'bool':
            return 'bool'

        if self.type.is_result_string():
            return 'string'

        if self.type.is_result_ptr():
            prefix = self.type.get_result_ptr_type_prefix()
            if self.parent.is_same_side(self.type.get_ptr_type()):
                return prefix + 'ptr_same'
            else:
                return prefix + 'ptr_diff'

        return 'invalid'

    def get_retval_default(self, for_capi):
        """ Returns the default return value based on the retval type. """
        # start with the default retval attribute, if any.
        retval = self.get_attrib_default_retval()
        if not retval is None:
            if for_capi:
                # apply any appropriate C API translations.
                if retval == 'true':
                    return '1'
                if retval == 'false':
                    return '0'
            return retval

        # next look at the retval type value.
        type = self.get_retval_type()
        if type == 'simple':
            return self.get_type().get_result_simple_default()
        elif type == 'bool':
            if for_capi:
                return '0'
            return 'false'
        elif type == 'string':
            if for_capi:
                return 'NULL'
            return 'CefString()'
        elif type == 'refptr_same' or type == 'refptr_diff' or \
             type == 'rawptr_same' or type == 'rawptr_diff':
            return 'NULL'
        elif type == 'ownptr_same' or type == 'ownptr_diff':
            if for_capi:
              return 'NULL'
            else:
              return 'CefOwnPtr<'+self.type.get_ptr_type()+'>()'

        return ''

class obj_analysis:
    """ Class representing an analysis of a data type value. """

    def __init__(self, scopelist, value, named):
        self.value = value
        self.result_type = 'unknown'
        self.result_value = None
        self.result_default = None
        self.ptr_type = None

        # parse the argument string
        partlist = string.split(string.strip(value))

        if named == True:
            # extract the name value
            self.name = partlist[-1]
            del partlist[-1]
        else:
            self.name = None

        if len(partlist) == 0:
            raise Exception('Invalid argument value: '+value)

        # check const status
        if partlist[0] == 'const':
            self.isconst = True
            del partlist[0]
        else:
            self.isconst = False

        if len(partlist) == 0:
            raise Exception('Invalid argument value: '+value)

        # combine the data type
        self.type = string.join(partlist, ' ')

        # extract the last character of the data type
        endchar = self.type[-1]

        # check if the value is passed by reference
        if endchar == '&':
            self.isbyref = True
            self.type = self.type[:-1]
        else:
            self.isbyref = False

        # check if the value is passed by address
        if endchar == '*':
            self.isbyaddr = True
            self.type = self.type[:-1]
        else:
            self.isbyaddr = False

        # see if the value is directly identifiable
        if self._check_advanced(self.type) == True:
            return

        # not identifiable, so look it up
        translation = None
        for scope in scopelist:
            if not isinstance(scope, obj_header) \
                and not isinstance(scope, obj_class):
                raise Exception('Invalid scope object type')
            translation = scope.get_alias_translation(self.type)
            if not translation is None:
                break

        if translation is None:
            raise Exception('Failed to translate type: '+self.type)

        # the translation succeeded so keep the result
        self.result_type = translation.result_type
        self.result_value = translation.result_value

    def _check_advanced(self, value):
        # check for vectors
        if value.find('std::vector') == 0:
            self.result_type = 'vector'
            val = string.strip(value[12:-1])
            self.result_value = [
                self._get_basic(val)
            ]
            self.result_value[0]['vector_type'] = val
            return True

        # check for maps
        if value.find('std::map') == 0:
            self.result_type = 'map'
            vals = string.split(value[9:-1], ',')
            if len(vals) == 2:
                self.result_value = [
                    self._get_basic(string.strip(vals[0])),
                    self._get_basic(string.strip(vals[1]))
                ]
                return True

        # check for multimaps
        if value.find('std::multimap') == 0:
            self.result_type = 'multimap'
            vals = string.split(value[14:-1], ',')
            if len(vals) == 2:
                self.result_value = [
                    self._get_basic(string.strip(vals[0])),
                    self._get_basic(string.strip(vals[1]))
                ]
                return True

        # check for basic types
        basic = self._get_basic(value)
        if not basic is None:
            self.result_type = basic['result_type']
            self.result_value = basic['result_value']
            if 'ptr_type' in basic:
                self.ptr_type = basic['ptr_type']
            if 'result_default' in basic:
                self.result_default = basic['result_default']
            return True

        return False

    def _get_basic(self, value):
        # check for string values
        if value == "CefString":
            return {
                'result_type' : 'string',
                'result_value' : None
            }

        # check for simple direct translations
        if value in _simpletypes.keys():
            return {
                'result_type' : 'simple',
                'result_value' : _simpletypes[value][0],
                'result_default' : _simpletypes[value][1],
            }

        # check if already a C API structure
        if value[-2:] == '_t':
            return {
                'result_type' : 'structure',
                'result_value' : value
            }

        # check for CEF reference pointers
        p = re.compile('^CefRefPtr<(.*?)>$', re.DOTALL)
        list = p.findall(value)
        if len(list) == 1:
            return {
                'result_type' : 'refptr',
                'result_value' : get_capi_name(list[0], True)+'*',
                'ptr_type' : list[0]
            }

        # check for CEF owned pointers
        p = re.compile('^CefOwnPtr<(.*?)>$', re.DOTALL)
        list = p.findall(value)
        if len(list) == 1:
            return {
                'result_type' : 'ownptr',
                'result_value' : get_capi_name(list[0], True)+'*',
                'ptr_type' : list[0]
            }

        # check for CEF raw pointers
        p = re.compile('^CefRawPtr<(.*?)>$', re.DOTALL)
        list = p.findall(value)
        if len(list) == 1:
            return {
                'result_type' : 'rawptr',
                'result_value' : get_capi_name(list[0], True)+'*',
                'ptr_type' : list[0]
            }

        # check for CEF structure types
        if value[0:3] == 'Cef' and value[-4:] != 'List':
            return {
                'result_type' : 'structure',
                'result_value' : get_capi_name(value, True)
            }

        return None

    def __repr__(self):
        return '('+self.result_type+') '+str(self.result_value)

    def has_name(self):
        """ Returns true if a name value exists. """
        return (not self.name is None)

    def get_name(self):
        """ Return the name. """
        return self.name

    def get_value(self):
        """ Return the C++ value (type + name). """
        return self.value

    def get_type(self):
        """ Return the C++ type. """
        return self.type

    def get_ptr_type(self):
        """ Return the C++ class type referenced by a CefRefPtr. """
        if self.is_result_vector() and self.is_result_vector_ptr():
            # return the vector RefPtr type
            return self.result_value[0]['ptr_type']
        # return the basic RefPtr type
        return self.ptr_type

    def get_vector_type(self):
        """ Return the C++ class type referenced by a std::vector. """
        if self.is_result_vector():
            return self.result_value[0]['vector_type']
        return None

    def is_const(self):
        """ Returns true if the argument value is constant. """
        return self.isconst

    def is_byref(self):
        """ Returns true if the argument is passed by reference. """
        return self.isbyref

    def is_byaddr(self):
        """ Returns true if the argument is passed by address. """
        return self.isbyaddr

    def is_result_simple(self):
        """ Returns true if this is a simple argument type. """
        return (self.result_type == 'simple')

    def get_result_simple_type_root(self):
        """ Return the simple structure or basic type name. """
        return self.result_value

    def get_result_simple_type(self):
        """ Return the simple type. """
        result = ''
        if self.is_const():
            result += 'const '
        result += self.result_value
        if self.is_byaddr() or self.is_byref():
            result += '*'
        return result

    def get_result_simple_default(self):
        """ Return the default value fo the basic type. """
        return self.result_default

    def is_result_ptr(self):
        """ Returns true if this is a *Ptr type. """
        return self.is_result_refptr() or self.is_result_ownptr() or \
               self.is_result_rawptr()

    def get_result_ptr_type_root(self):
        """ Return the *Ptr type structure name. """
        return self.result_value[:-1]

    def get_result_ptr_type(self, defined_structs = []):
        """ Return the *Ptr type. """
        result = ''
        if not self.result_value[:-1] in defined_structs:
            result += 'struct _'
        result += self.result_value
        if self.is_byref() or self.is_byaddr():
            result += '*'
        return result

    def get_result_ptr_type_prefix(self):
        """ Returns the *Ptr type prefix. """
        if self.is_result_refptr():
            return 'ref'
        if self.is_result_ownptr():
            return 'own'
        if self.is_result_rawptr():
            return 'raw'
        raise Exception('Not a pointer type')

    def is_result_refptr(self):
        """ Returns true if this is a RefPtr type. """
        return (self.result_type == 'refptr')

    def is_result_ownptr(self):
        """ Returns true if this is a OwnPtr type. """
        return (self.result_type == 'ownptr')

    def is_result_rawptr(self):
        """ Returns true if this is a RawPtr type. """
        return (self.result_type == 'rawptr')

    def is_result_struct(self):
        """ Returns true if this is a structure type. """
        return (self.result_type == 'structure')

    def is_result_struct_enum(self):
        """ Returns true if this struct type is likely an enumeration. """
        # structure values that are passed by reference or address must be
        # structures and not enumerations
        if not self.is_byref() and not self.is_byaddr():
            return True
        return False

    def get_result_struct_type(self, defined_structs = []):
        """ Return the structure or enumeration type. """
        result = ''
        is_enum = self.is_result_struct_enum()
        if not is_enum:
            if self.is_const():
                result += 'const '
            if not self.result_value in defined_structs:
                result += 'struct _'
        result += self.result_value
        if not is_enum:
            result += '*'
        return result

    def is_result_string(self):
        """ Returns true if this is a string type. """
        return (self.result_type == 'string')

    def get_result_string_type(self):
        """ Return the string type. """
        if not self.has_name():
            # Return values are string structs that the user must free. Use
            # the name of the structure as a hint.
            return 'cef_string_userfree_t'
        elif not self.is_const() and (self.is_byref() or self.is_byaddr()):
            # Parameters passed by reference or address. Use the normal
            # non-const string struct.
            return 'cef_string_t*'
        # Const parameters use the const string struct.
        return 'const cef_string_t*'

    def is_result_vector(self):
        """ Returns true if this is a vector type. """
        return (self.result_type == 'vector')

    def is_result_vector_string(self):
        """ Returns true if this is a string vector. """
        return self.result_value[0]['result_type'] == 'string'

    def is_result_vector_simple(self):
        """ Returns true if this is a string vector. """
        return self.result_value[0]['result_type'] == 'simple'

    def is_result_vector_ptr(self):
        """ Returns true if this is a *Ptr vector. """
        return self.is_result_vector_refptr() or \
               self.is_result_vector_ownptr() or \
               self.is_result_vector_rawptr()

    def get_result_vector_ptr_type_prefix(self):
        """ Returns the *Ptr type prefix. """
        if self.is_result_vector_refptr():
            return 'ref'
        if self.is_result_vector_ownptr():
            return 'own'
        if self.is_result_vector_rawptr():
            return 'raw'
        raise Exception('Not a pointer type')

    def is_result_vector_refptr(self):
        """ Returns true if this is a RefPtr vector. """
        return self.result_value[0]['result_type'] == 'refptr'

    def is_result_vector_ownptr(self):
        """ Returns true if this is a OwnPtr vector. """
        return self.result_value[0]['result_type'] == 'ownptr'

    def is_result_vector_rawptr(self):
        """ Returns true if this is a RawPtr vector. """
        return self.result_value[0]['result_type'] == 'rawptr'

    def get_result_vector_type_root(self):
        """ Return the vector structure or basic type name. """
        return self.result_value[0]['result_value']

    def get_result_vector_type(self, defined_structs = []):
        """ Return the vector type. """
        if not self.has_name():
            raise Exception('Cannot use vector as a return type')

        type = self.result_value[0]['result_type']
        value = self.result_value[0]['result_value']

        result = {}
        if type == 'string':
            result['value'] = 'cef_string_list_t'
            result['format'] = 'single'
            return result

        if type == 'simple':
            str = value
            if self.is_const():
                str += ' const'
            str += '*'
            result['value'] = str
        elif type == 'refptr' or type == 'ownptr' or type == 'rawptr':
            str = ''
            if not value[:-1] in defined_structs:
                str += 'struct _'
            str += value
            if self.is_const():
                str += ' const'
            str += '*'
            result['value'] = str
        else:
            raise Exception('Unsupported vector type: '+type)

        # vector values must be passed as a value array parameter
        # and a size parameter
        result['format'] = 'multi-arg'
        return result

    def is_result_map(self):
        """ Returns true if this is a map type. """
        return (self.result_type == 'map' or self.result_type == 'multimap')

    def is_result_map_single(self):
        """ Returns true if this is a single map type. """
        return (self.result_type == 'map')

    def is_result_map_multi(self):
        """ Returns true if this is a multi map type. """
        return (self.result_type == 'multimap')

    def get_result_map_type(self, defined_structs = []):
        """ Return the map type. """
        if not self.has_name():
            raise Exception('Cannot use map as a return type')
        if self.result_value[0]['result_type'] == 'string' \
            and self.result_value[1]['result_type'] == 'string':
            if self.result_type == 'map':
                return {
                    'value' : 'cef_string_map_t',
                    'format' : 'single'
                }
            elif self.result_type == 'multimap':
                return {
                    'value' : 'cef_string_multimap_t',
                    'format' : 'multi'
                }
        raise Exception('Only mappings of strings to strings are supported')

    def get_capi(self, defined_structs = []):
        """ Format the value for the C API. """
        result = ''
        format = 'single'
        if self.is_result_simple():
            result += self.get_result_simple_type()
        elif self.is_result_ptr():
            result += self.get_result_ptr_type(defined_structs)
        elif self.is_result_struct():
            result += self.get_result_struct_type(defined_structs)
        elif self.is_result_string():
            result += self.get_result_string_type()
        elif self.is_result_map():
            resdict = self.get_result_map_type(defined_structs)
            if resdict['format'] == 'single' or resdict['format'] == 'multi':
                result += resdict['value']
            else:
                raise Exception('Unsupported map type')
        elif self.is_result_vector():
            resdict = self.get_result_vector_type(defined_structs)
            if resdict['format'] != 'single':
                format = resdict['format']
            result += resdict['value']

        if self.has_name():
            result += ' '+self.get_name()

        return {'format' : format, 'value' : result}


# test the module
if __name__ == "__main__":
    import pprint
    import sys

    # verify that the correct number of command-line arguments are provided
    if len(sys.argv) != 2:
        sys.stderr.write('Usage: '+sys.argv[0]+' <directory>')
        sys.exit()

    pp = pprint.PrettyPrinter(indent=4)

    # create the header object
    header = obj_header()
    header.add_directory(sys.argv[1])

    # output the type mapping
    types = {}
    header.get_types(types)
    pp.pprint(types)
    sys.stdout.write('\n')

    # output the parsed C++ data
    sys.stdout.write(wrap_code(str(header), '\t'))

    # output the C API formatted data
    defined_names = header.get_defined_structs()
    result = ''

    # global functions
    funcs = header.get_funcs()
    if len(funcs) > 0:
        for func in funcs:
            result += func.get_capi_proto(defined_names)+';\n'
        result += '\n'

    classes = header.get_classes()
    for cls in classes:
        # virtual functions are inside a structure
        result += 'struct '+cls.get_capi_name()+'\n{\n'
        funcs = cls.get_virtual_funcs()
        if len(funcs) > 0:
            for func in funcs:
                result += '\t'+func.get_capi_proto(defined_names)+';\n'
        result += '}\n\n'

        defined_names.append(cls.get_capi_name())

        # static functions become global
        funcs = cls.get_static_funcs()
        if len(funcs) > 0:
            for func in funcs:
                result += func.get_capi_proto(defined_names)+';\n'
            result += '\n'
    sys.stdout.write(wrap_code(result, '\t'))
